package org.xtext.example.cr.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
import org.xtext.example.cr.cR.Add;
import org.xtext.example.cr.cR.Archive;
import org.xtext.example.cr.cR.Array;
import org.xtext.example.cr.cR.ArrayDec;
import org.xtext.example.cr.cR.ArrayElement;
import org.xtext.example.cr.cR.ArrayMethod;
import org.xtext.example.cr.cR.Assignment;
import org.xtext.example.cr.cR.CRFunction;
import org.xtext.example.cr.cR.CRLanguage;
import org.xtext.example.cr.cR.CRPackage;
import org.xtext.example.cr.cR.CalcCR;
import org.xtext.example.cr.cR.CalcMean;
import org.xtext.example.cr.cR.Delete;
import org.xtext.example.cr.cR.Element;
import org.xtext.example.cr.cR.FindSimilar;
import org.xtext.example.cr.cR.Folder;
import org.xtext.example.cr.cR.For;
import org.xtext.example.cr.cR.Forall;
import org.xtext.example.cr.cR.Function;
import org.xtext.example.cr.cR.HighestCR;
import org.xtext.example.cr.cR.Index;
import org.xtext.example.cr.cR.IntDec;
import org.xtext.example.cr.cR.LinuxFolder;
import org.xtext.example.cr.cR.PartitionDec;
import org.xtext.example.cr.cR.PrimitiveDec;
import org.xtext.example.cr.cR.Print;
import org.xtext.example.cr.cR.RealDec;
import org.xtext.example.cr.cR.SimpleVariable;
import org.xtext.example.cr.cR.Size;
import org.xtext.example.cr.cR.StandardFunction;
import org.xtext.example.cr.cR.VarDec;
import org.xtext.example.cr.cR.WindowsFolder;
import org.xtext.example.cr.services.CRGrammarAccess;

@SuppressWarnings("restriction")
public class AbstractCRSemanticSequencer extends AbstractSemanticSequencer {

	@Inject
	protected CRGrammarAccess grammarAccess;
	
	@Inject
	protected ISemanticSequencerDiagnosticProvider diagnosticProvider;
	
	@Inject
	protected ITransientValueService transientValues;
	
	@Inject
	@GenericSequencer
	protected Provider<ISemanticSequencer> genericSequencerProvider;
	
	protected ISemanticSequencer genericSequencer;
	
	
	@Override
	public void init(ISemanticSequencer sequencer, ISemanticSequenceAcceptor sequenceAcceptor, Acceptor errorAcceptor) {
		super.init(sequencer, sequenceAcceptor, errorAcceptor);
		this.genericSequencer = genericSequencerProvider.get();
		this.genericSequencer.init(sequencer, sequenceAcceptor, errorAcceptor);
	}
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == CRPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case CRPackage.ADD:
				if(context == grammarAccess.getAddRule()) {
					sequence_Add(context, (Add) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.ARCHIVE:
				if(context == grammarAccess.getArchiveRule()) {
					sequence_Archive(context, (Archive) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.ARRAY:
				if(context == grammarAccess.getArrayRule()) {
					sequence_Array(context, (Array) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getVariableRule()) {
					sequence_Variable(context, (Array) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.ARRAY_DEC:
				if(context == grammarAccess.getArrayDecRule()) {
					sequence_ArrayDec(context, (ArrayDec) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.ARRAY_ELEMENT:
				if(context == grammarAccess.getArrayElementRule()) {
					sequence_ArrayElement(context, (ArrayElement) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.ARRAY_METHOD:
				if(context == grammarAccess.getArrayMethodRule()) {
					sequence_ArrayMethod(context, (ArrayMethod) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.ASSIGNMENT:
				if(context == grammarAccess.getAssignmentRule()) {
					sequence_Assignment(context, (Assignment) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.CR_FUNCTION:
				if(context == grammarAccess.getCRFunctionRule()) {
					sequence_CRFunction(context, (CRFunction) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.CR_LANGUAGE:
				if(context == grammarAccess.getCRLanguageRule()) {
					sequence_CRLanguage(context, (CRLanguage) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.CALC_CR:
				if(context == grammarAccess.getCalcCRRule()) {
					sequence_CalcCR(context, (CalcCR) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.CALC_MEAN:
				if(context == grammarAccess.getCalcMeanRule()) {
					sequence_CalcMean(context, (CalcMean) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.DELETE:
				if(context == grammarAccess.getDeleteRule()) {
					sequence_Delete(context, (Delete) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.ELEMENT:
				if(context == grammarAccess.getElementRule()) {
					sequence_Element(context, (Element) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.FIND_SIMILAR:
				if(context == grammarAccess.getFindSimilarRule()) {
					sequence_FindSimilar(context, (FindSimilar) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.FOLDER:
				if(context == grammarAccess.getFolderRule()) {
					sequence_Folder(context, (Folder) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.FOR:
				if(context == grammarAccess.getForRule()) {
					sequence_For(context, (For) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.FORALL:
				if(context == grammarAccess.getForallRule()) {
					sequence_Forall(context, (Forall) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.FUNCTION:
				if(context == grammarAccess.getFunctionRule()) {
					sequence_Function(context, (Function) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.HIGHEST_CR:
				if(context == grammarAccess.getHighestCRRule()) {
					sequence_HighestCR(context, (HighestCR) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.INDEX:
				if(context == grammarAccess.getIndexRule()) {
					sequence_Index(context, (Index) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.INT_DEC:
				if(context == grammarAccess.getIntDecRule()) {
					sequence_IntDec(context, (IntDec) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.LINUX_FOLDER:
				if(context == grammarAccess.getLinuxFolderRule()) {
					sequence_LinuxFolder(context, (LinuxFolder) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.NUMBER:
				if(context == grammarAccess.getNumberRule()) {
					sequence_Number(context, (org.xtext.example.cr.cR.Number) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.PARTITION_DEC:
				if(context == grammarAccess.getPartitionDecRule()) {
					sequence_PartitionDec(context, (PartitionDec) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.PRIMITIVE_DEC:
				if(context == grammarAccess.getPrimitiveDecRule()) {
					sequence_PrimitiveDec(context, (PrimitiveDec) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.PRINT:
				if(context == grammarAccess.getPrintRule()) {
					sequence_Print(context, (Print) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.REAL_DEC:
				if(context == grammarAccess.getRealDecRule()) {
					sequence_RealDec(context, (RealDec) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.SIMPLE_VARIABLE:
				if(context == grammarAccess.getSimpleVariableRule()) {
					sequence_SimpleVariable(context, (SimpleVariable) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getVariableRule()) {
					sequence_Variable(context, (SimpleVariable) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.SIZE:
				if(context == grammarAccess.getSizeRule()) {
					sequence_Size(context, (Size) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.STANDARD_FUNCTION:
				if(context == grammarAccess.getStandardFunctionRule()) {
					sequence_StandardFunction(context, (StandardFunction) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.VAR_DEC:
				if(context == grammarAccess.getVarDecRule()) {
					sequence_VarDec(context, (VarDec) semanticObject); 
					return; 
				}
				else break;
			case CRPackage.WINDOWS_FOLDER:
				if(context == grammarAccess.getWindowsFolderRule()) {
					sequence_WindowsFolder(context, (WindowsFolder) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (
	 *         (array=[Array|ID] | arrayElement=ArrayElement) 
	 *         method='add' 
	 *         (
	 *             numParams+=Number | 
	 *             varParams+=[Variable|ID] | 
	 *             aeParams+=ArrayElement | 
	 *             archive+=Archive | 
	 *             sizes+=Size | 
	 *             calcCRs+=CalcCR | 
	 *             calcMeans+=CalcMean
	 *         ) 
	 *         (
	 *             numParams+=Number | 
	 *             varParams+=[Variable|ID] | 
	 *             aeParams+=ArrayElement | 
	 *             archive+=Archive | 
	 *             sizes+=Size | 
	 *             calcCRs+=CalcCR | 
	 *             calcMeans+=CalcMean
	 *         )*
	 *     )
	 */
	protected void sequence_Add(EObject context, Add semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (folder=Folder? arq+=ID arq+='.' arq+='clu')
	 */
	protected void sequence_Archive(EObject context, Archive semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         array='array' 
	 *         colums=INT 
	 *         rows=INT? 
	 *         (type='Int' | type='Real' | type='Partition') 
	 *         arrayVars+=Array 
	 *         arrayVars+=Array*
	 *     )
	 */
	protected void sequence_ArrayDec(EObject context, ArrayDec semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (array=[Array|ID] idx=Index)
	 */
	protected void sequence_ArrayElement(EObject context, ArrayElement semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.ARRAY_ELEMENT__ARRAY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.ARRAY_ELEMENT__ARRAY));
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.ARRAY_ELEMENT__IDX) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.ARRAY_ELEMENT__IDX));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getArrayElementAccess().getArrayArrayIDTerminalRuleCall_0_0_1(), semanticObject.getArray());
		feeder.accept(grammarAccess.getArrayElementAccess().getIdxIndexParserRuleCall_1_0(), semanticObject.getIdx());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (size=Size | add=Add | delete=Delete)
	 */
	protected void sequence_ArrayMethod(EObject context, ArrayMethod semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_Array(EObject context, Array semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         (dec=VarDec | (variables+=[Variable|ID] variables+=[Variable|ID]*) | arrayElement=ArrayElement) 
	 *         (
	 *             calcCR=CalcCR | 
	 *             calcMean=CalcMean | 
	 *             number=Number | 
	 *             archive=Archive | 
	 *             variable=[Variable|ID] | 
	 *             assignedAE=ArrayElement
	 *         )
	 *     )
	 */
	protected void sequence_Assignment(EObject context, Assignment semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (calcCR=CalcCR | calcMean=CalcMean | highestCR=HighestCR | findSimilar=FindSimilar)
	 */
	protected void sequence_CRFunction(EObject context, CRFunction semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     elements+=Element*
	 */
	protected void sequence_CRLanguage(EObject context, CRLanguage semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         (function='calcCR' (vector=[Array|ID] | arrayElement=ArrayElement)) | 
	 *         (function='calcCR' (arrayElement1=ArrayElement | var1=[SimpleVariable|ID]) (arrayElement2=ArrayElement | var2=[Variable|ID]))
	 *     )
	 */
	protected void sequence_CalcCR(EObject context, CalcCR semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (function='calcMean' (array=[Array|ID] | arrayElement=ArrayElement | calcCR=CalcCR))
	 */
	protected void sequence_CalcMean(EObject context, CalcMean semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         (
	 *             (array=[Array|ID] | arrayElement=ArrayElement) 
	 *             method='delete' 
	 *             (delElements+=INT | delVars+=[SimpleVariable|ID] | delArrays+=ArrayElement | size+=Size) 
	 *             (delElements+=INT | delVars+=[SimpleVariable|ID] | delArrays+=ArrayElement | size+=Size)*
	 *         ) | 
	 *         (
	 *             (array=[Array|ID] | arrayElement=ArrayElement) 
	 *             method='delete' 
	 *             (indexs+=Index | findSimilars+=FindSimilar | highestCRs+=HighestCR) 
	 *             (indxs+=Index | findSimilars+=FindSimilar | highestCRs+=HighestCR)*
	 *         )
	 *     )
	 */
	protected void sequence_Delete(EObject context, Delete semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (varDec=VarDec | assignment=Assignment | arrayMethod=ArrayMethod | function=Function)
	 */
	protected void sequence_Element(EObject context, Element semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         function='findSimilar' 
	 *         matrix=[Array|ID] 
	 *         (indxInt=INT | indxVar=[SimpleVariable|ID] | indxAE=ArrayElement) 
	 *         (similarityNum=Number | similarityVar=[SimpleVariable|ID] | similarityAE=ArrayElement | similarityCalcCR=CalcCR | similarityCalcMean=CalcMean)
	 *     )
	 */
	protected void sequence_FindSimilar(EObject context, FindSimilar semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (linuxFolder=LinuxFolder | windowsFolder=WindowsFolder)
	 */
	protected void sequence_Folder(EObject context, Folder semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((function='for' locVar=[SimpleVariable|ID] dir=Folder innerElements+=Element*) | (function='for' var=[Array|ID] innerElements+=Element*))
	 */
	protected void sequence_For(EObject context, For semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         function='forall' 
	 *         locVar=[SimpleVariable|ID] 
	 *         (begin=INT | beginVar=[SimpleVariable|ID] | beginFunction=Size | beginAE=ArrayElement) 
	 *         (end=INT | endVar=[SimpleVariable|ID] | endFunction=Size | endAE=ArrayElement) 
	 *         innerElements+=Element*
	 *     )
	 */
	protected void sequence_Forall(EObject context, Forall semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (standardFunction=StandardFunction | crFunction=CRFunction)
	 */
	protected void sequence_Function(EObject context, Function semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (function='highestCR' (array=[Array|ID] | arrayElement=ArrayElement | calcCR=CalcCR))
	 */
	protected void sequence_HighestCR(EObject context, HighestCR semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((param1=INT | var1=[SimpleVariable|ID]) (param2=INT | var2=[SimpleVariable|ID])?)
	 */
	protected void sequence_Index(EObject context, Index semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type='Int' vars+=SimpleVariable vars+=SimpleVariable*)
	 */
	protected void sequence_IntDec(EObject context, IntDec semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (unixFolder+='/' (unixFolder+=ID unixFolder+='/')*)
	 */
	protected void sequence_LinuxFolder(EObject context, LinuxFolder semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (integer=INT decimal=INT?)
	 */
	protected void sequence_Number(EObject context, org.xtext.example.cr.cR.Number semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type='Partition' vars+=SimpleVariable vars+=SimpleVariable*)
	 */
	protected void sequence_PartitionDec(EObject context, PartitionDec semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (intDec=IntDec | realDec=RealDec | partitionDec=PartitionDec)
	 */
	protected void sequence_PrimitiveDec(EObject context, PrimitiveDec semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (function='print' (var+=[Variable|ID] | msg+=STRING | aeParam+=ArrayElement) (var+=[Variable|ID] | msg+=STRING | aeParam+=ArrayElement)*)
	 */
	protected void sequence_Print(EObject context, Print semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (type='Real' vars+=SimpleVariable vars+=SimpleVariable*)
	 */
	protected void sequence_RealDec(EObject context, RealDec semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_SimpleVariable(EObject context, SimpleVariable semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((array=[Array|ID] | arrayElement=ArrayElement) method='size')
	 */
	protected void sequence_Size(EObject context, Size semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (print=Print | for=For | forall=Forall)
	 */
	protected void sequence_StandardFunction(EObject context, StandardFunction semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (primitiveDec=PrimitiveDec | arrayDec=ArrayDec)
	 */
	protected void sequence_VarDec(EObject context, VarDec semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID isMatrix='' type='' isArray='')
	 */
	protected void sequence_Variable(EObject context, Array semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__IS_MATRIX) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__IS_MATRIX));
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__TYPE));
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__IS_ARRAY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__IS_ARRAY));
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getArrayAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getVariableAccess().getIsMatrixKeyword_1_0(), semanticObject.getIsMatrix());
		feeder.accept(grammarAccess.getVariableAccess().getTypeKeyword_2_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getVariableAccess().getIsArrayKeyword_3_0(), semanticObject.getIsArray());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID isMatrix='' type='' isArray='')
	 */
	protected void sequence_Variable(EObject context, SimpleVariable semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__IS_MATRIX) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__IS_MATRIX));
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__TYPE));
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__IS_ARRAY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__IS_ARRAY));
			if(transientValues.isValueTransient(semanticObject, CRPackage.Literals.VARIABLE__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CRPackage.Literals.VARIABLE__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSimpleVariableAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getVariableAccess().getIsMatrixKeyword_1_0(), semanticObject.getIsMatrix());
		feeder.accept(grammarAccess.getVariableAccess().getTypeKeyword_2_0(), semanticObject.getType());
		feeder.accept(grammarAccess.getVariableAccess().getIsArrayKeyword_3_0(), semanticObject.getIsArray());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (windowsFolder+=ID windowsFolder+=':/' (windowsFolder+=ID windowsFolder+='/')*)
	 */
	protected void sequence_WindowsFolder(EObject context, WindowsFolder semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}
